home *** CD-ROM | disk | FTP | other *** search
/ Linux Cubed Series 7: Sunsite / Linux Cubed Series 7 - Sunsite Vol 1.iso / system / filesyst / dosfs / dmsdosfs.000 / dmsdosfs / dmsdosfs-0.6.9b / dmsdos_dec.c < prev    next >
C/C++ Source or Header  |  1996-07-29  |  8KB  |  295 lines
  1. /*
  2. linux/fs/dmsdos/dmsdos_dec.c
  3.  
  4. DMSDOS filesystem: decompression routines
  5.  
  6. ******************************************************************************
  7. DMSDOS (Doublespace/Drivespace compressed MSDOS filesystem) for Linux
  8. written 1995,1996 by Frank Gockel
  9.  
  10.     (C) Copyright 1995,1996 by Frank Gockel
  11.  
  12. Some code of the dmsdos filesystem has been copied from the msdos filesystem
  13. so there are the following additional copyrights:
  14.  
  15.     (C) Copyright 1992,1993 by Werner Almesberger (msdos filesystem)
  16.     (C) Copyright 1994,1995 by Jacques Gelinas (mmap code)
  17.     (C) Copyright 1992-1995 by Linus Torvalds
  18.  
  19. The DMSDOS filesystem was inspired by the THS filesystem (a simple doublespace
  20. DS-0-2 compressed read-only filesystem) written 1994 by Thomas Scheuermann.
  21.  
  22. The DMSDOS filesystem is distributed under the Gnu General Public Licence.
  23. See file COPYING for details.
  24. ******************************************************************************
  25.                                                         
  26. */
  27.  
  28. #include <linux/kernel.h>
  29. #include <linux/sched.h>
  30. #include <linux/errno.h>
  31. #include <linux/string.h>
  32. #include <linux/stat.h>
  33. #include <linux/mm.h>
  34. #include <linux/locks.h>
  35. #include <linux/fs.h>
  36. #include <linux/malloc.h>
  37. #include <linux/msdos_fs.h>
  38. #include <linux/dmsdos_fs.h>
  39.  
  40. #include <asm/system.h>
  41. #include <asm/segment.h>
  42. #include <asm/bitops.h>
  43.  
  44. extern Dblsb dblsb[];
  45.  
  46. /* cluster caching...has to be reprogrammed (?)
  47.    disabled due to multiple read problems 
  48.    (besides, I did not notice any speedup)
  49. unsigned char* ldc=NULL;
  50. int ldc_cvfnr;
  51. int ldc_cnr;
  52. */
  53.  
  54. /* known compression methods */
  55. /* see header file */
  56.  
  57. /* some functions are inline for speed reasons - this eats kernel memory */
  58.  
  59. inline int getbit(unsigned char*clusterk,int*mask,int*count)
  60. { int ret;
  61.  
  62.   ret=(*mask)&clusterk[*count];
  63.   (*mask)<<=1;
  64.   if(*mask==256)
  65.   { *mask=1;
  66.     (*count)++;
  67.   }  
  68.   return ret;
  69. }
  70.  
  71. int getbits(unsigned char*clusterk,int*mask,int*count,int bits)
  72. { int orwert=1;
  73.   int ret=0;
  74.   int i;
  75.   
  76.   for(i=0;i<bits;++i)
  77.   { if(getbit(clusterk,mask,count))ret|=orwert;
  78.     orwert<<=1;
  79.   }
  80.   return ret;
  81. }
  82.  
  83. int getDX(unsigned char*clusterk,int*mask,int*count)
  84. { if(!getbit(clusterk,mask,count)) return getbits(clusterk,mask,count,6);
  85.   if(!getbit(clusterk,mask,count)) return getbits(clusterk,mask,count,8)+64;
  86.   return getbits(clusterk,mask,count,12)+320;
  87. }
  88.  
  89. int getCX(unsigned char*clusterk,int*mask,int*count)
  90. { if(getbit(clusterk,mask,count)) return 3;
  91.   if(getbit(clusterk,mask,count)) return getbits(clusterk,mask,count,1)+4;
  92.   if(getbit(clusterk,mask,count)) return getbits(clusterk,mask,count,2)+6;
  93.   if(getbit(clusterk,mask,count)) return getbits(clusterk,mask,count,3)+10;
  94.   if(getbit(clusterk,mask,count)) return getbits(clusterk,mask,count,4)+18;
  95.   if(getbit(clusterk,mask,count)) return getbits(clusterk,mask,count,5)+34;
  96.   if(getbit(clusterk,mask,count)) return getbits(clusterk,mask,count,6)+66;
  97.   if(getbit(clusterk,mask,count)) return getbits(clusterk,mask,count,7)+130;
  98.   if(getbit(clusterk,mask,count)) return getbits(clusterk,mask,count,8)+258;
  99.   return -1;
  100. }
  101.  
  102. int decrb(unsigned char*clusterk,int*mask,int*count,
  103.           unsigned char*clusterd,int*pos,int*sek,int dx,int k)
  104. { int i,cx;
  105.  
  106.   if(dx==0)return -2;
  107.   if(dx==0x113f)
  108.   { /*printk("DMSDOS: decrb: 0x113f sync found.\n");*/
  109.     (*sek)--;
  110.     if(*sek==0)return -1;
  111.     if(*pos%SECTOR_SIZE) return -2;
  112.     return 0;
  113.   }
  114.   cx=getCX(clusterk,mask,count)+k;
  115.   if(cx<=0)return -2;
  116.   if(dx>*pos) return -2;
  117.   for(i=0;i<cx;i++)clusterd[(*pos)+i]=clusterd[(*pos)+i-dx];
  118.   (*pos)+=cx;
  119.   return 0;
  120. }
  121.  
  122. /* decompress a compressed cluster clusterk to clusterd */
  123. int decompress(unsigned char*clusterd, unsigned char*clusterk,
  124.                Mdfat_entry*mde)
  125. {
  126.     int sekcount;
  127.     int r,count,mask,pos,dx;
  128.  
  129.     /*printk("DMSDOS: decompress: mdfatval=%d\n",mdfatval);*/
  130.  
  131.     sekcount=mde->size_hi_minus_1+1;
  132.     count=0;
  133.     mask=1;
  134.     pos=0;
  135.  
  136.   switch(getbits(clusterk,&mask,&count,32))
  137.   {
  138.     case DS_0_0:
  139.     case DS_0_1:
  140.     case DS_0_2:
  141.     /*printk("DMSDOS: decompressing DS-0-x\n");*/
  142.         do
  143.         { r=0;
  144.           if(!getbit(clusterk,&mask,&count))
  145.           { if(getbit(clusterk,&mask,&count))
  146.             { clusterd[pos++]=getbits(clusterk,&mask,&count,7);
  147.             }
  148.             else
  149.             { dx=getbits(clusterk,&mask,&count,6);
  150.               r=decrb(clusterk,&mask,&count,clusterd,&pos,&sekcount,dx,-1);
  151.             }
  152.           }
  153.           else
  154.           { if(!getbit(clusterk,&mask,&count))
  155.             { clusterd[pos++]=getbits(clusterk,&mask,&count,7)|128;
  156.             }
  157.             else
  158.             { dx=(!getbit(clusterk,&mask,&count)) ?
  159.                      getbits(clusterk,&mask,&count,8)+64 :
  160.                      getbits(clusterk,&mask,&count,12)+320;
  161.               r=decrb(clusterk,&mask,&count,clusterd,&pos,&sekcount,dx,-1);
  162.             }
  163.           }
  164.         }
  165.         while(r==0);
  166.         if(r==-2)
  167.         { printk("DMSDOS: error in DS-0-x compressed data.\n");
  168.           return -2;
  169.         }    
  170.         /*printk("DMSDOS: decompress finished.\n");*/
  171.     return 0;
  172.     
  173.     case JM_0_0:
  174.     case JM_0_1:
  175.     /*printk("DMSDOS: decompressing JM-0-x\n");*/
  176.     do
  177.     { r=0;
  178.       if(!getbit(clusterk,&mask,&count))
  179.       { clusterd[pos++]=getbits(clusterk,&mask,&count,7);
  180.       }
  181.       else
  182.       { if(!getbit(clusterk,&mask,&count))
  183.         { dx=getDX(clusterk,&mask,&count);
  184.           r=decrb(clusterk,&mask,&count,clusterd,&pos,&sekcount,dx,0);
  185.         }
  186.         else
  187.         { clusterd[pos++]=getbits(clusterk,&mask,&count,7)|128;
  188.         }
  189.       }
  190.     }
  191.     while(r==0);
  192.     if(r==-2)
  193.     { printk("DMSDOS: error in JM-0-x compressed data.\n");
  194.       return -2;
  195.     }
  196.     /*printk("DMSDOS: decompress finished.\n");*/
  197.     return 0;
  198.  
  199.     case SQ_0_0:
  200.         printk("DMSDOS: Sorry, SQ-0-0 compression not yet supported.\n");    
  201.         return -1;
  202.         
  203.     default:    
  204.     printk("DMSDOS: compression method not recognized.\n");
  205.     return -1;
  206.     
  207.   } /* end switch */
  208.   
  209.   return 0;
  210. }
  211.  
  212. /* read a complete file cluster and decompress it if necessary; 
  213.    currently only called by dmsdos_file_read;
  214.    do not use to read directory clusters (for speed reasons);
  215.    this function is unable to read cluster 0 (CVF root directory) */
  216. int dmsdos_read_cluster(struct super_block*sb,
  217.                         unsigned char*clusterd, int clusternr,int cvfnr)
  218. {    Mdfat_entry mde;
  219.     unsigned char*clusterk;
  220.     int anz_sektoren;
  221.     int i;
  222.     struct buffer_head*bh;
  223.     int membytes;
  224.     int sektor;
  225.     /*int fullsize;*/
  226.  
  227.         LOCK_READWRITE;
  228.     /*printk("DMSDOS: read_cluster %d in CVF %d\n",clusternr,cvfnr+1);*/
  229.  
  230.     dbl_mdfat_value(sb,clusternr,cvfnr,NULL,&mde);
  231.     
  232.     if((mde.flags&2)==0)
  233.     { /* hmm, cluster is unused (it's a lost or ghost cluster)
  234.          and contains undefined data, but it *is* readable */
  235.       printk("DMSDOS: lost cluster %d in CVF %d detected\n",clusternr,
  236.              cvfnr+1);
  237.       UNLOCK_READWRITE;
  238.       return 0;
  239.     }
  240.     
  241.         sektor=mde.sector_minus_1+1;
  242.         anz_sektoren=mde.size_lo_minus_1+1;/* real sectors on disk */
  243.         if(anz_sektoren>dblsb[cvfnr].s_sectperclust)
  244.         { printk("DMSDOS: read_cluster: mdfat sektors > sectperclust, cutting\n");
  245.           anz_sektoren=dblsb[cvfnr].s_sectperclust;
  246.         }
  247.         
  248.         if(mde.flags&1)
  249.         {  /* cluster is not compressed */
  250.        for(i=0;i<anz_sektoren;++i)
  251.        {  bh=read_dbl_sector(sb,sektor+i,cvfnr);
  252.           if(bh==NULL){UNLOCK_READWRITE;return -EIO;}
  253.           memcpy(&clusterd[i*SECTOR_SIZE],bh->b_data,SECTOR_SIZE);
  254.           bh_free(sb,bh);
  255.        }
  256.         }
  257.         else
  258.         {  /* cluster is compressed */
  259.            
  260.            membytes=SECTOR_SIZE*anz_sektoren;
  261.            
  262.            clusterk=(unsigned char*)MALLOC(membytes);
  263.            if(clusterk==NULL)
  264.            { printk("DMSDOS: no memory for decompression!\n");
  265.              UNLOCK_READWRITE;
  266.              return -2;
  267.            }
  268.            
  269.            for(i=0;i<anz_sektoren;++i)
  270.        {  bh=read_dbl_sector(sb,sektor+i,cvfnr);
  271.           if(bh==NULL)
  272.           { FREE(clusterk);
  273.             UNLOCK_READWRITE;
  274.             return -EIO;
  275.           }
  276.           memcpy(&clusterk[i*SECTOR_SIZE],bh->b_data,SECTOR_SIZE);
  277.           bh_free(sb,bh);
  278.        }
  279.        
  280.            i=decompress(clusterd,clusterk,&mde);
  281.            
  282.            FREE(clusterk);
  283.            
  284.            if(i)
  285.            { printk("DMSDOS: decompression of cluster %d in CVF %d failed.\n",
  286.                     clusternr,cvfnr+1);
  287.              UNLOCK_READWRITE;
  288.              return i;
  289.            }
  290.            
  291.         }
  292.  
  293.         UNLOCK_READWRITE;
  294.     return 0;
  295. }